home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / vbdatabs / float64.h < prev    next >
C/C++ Source or Header  |  1999-03-14  |  13KB  |  254 lines
  1. // ------------------------------- //
  2. // -------- Start of File -------- //
  3. // ------------------------------- //
  4. // ----------------------------------------------------------- //
  5. // C++ Header File Name: float64.h 
  6. // Compiler Used: MSVC40, DJGPP 2.7.2.1, GCC 2.7.2.1, HP CPP 10.24
  7. // Produced By: Doug Gaer   
  8. // File Creation Date: 09/12/1997  
  9. // Date Last Modified: 03/15/1999
  10. // Copyright (c) 1997 Douglas M. Gaer
  11. // ----------------------------------------------------------- // 
  12. // ---------- Include File Description and Details  ---------- // 
  13. // ----------------------------------------------------------- // 
  14. /*
  15. The VBD C++ classes are copyright (c) 1997, by Douglas M. Gaer.
  16. All those who put this code or its derivatives in a commercial
  17. product MUST mention this copyright in their documentation for
  18. users of the products in which this code or its derivative
  19. classes are used. Otherwise, you have the freedom to redistribute
  20. verbatim copies of this source code, adapt it to your specific
  21. needs, or improve the code and release your improvements to the
  22. public provided that the modified files carry prominent notices
  23. stating that you changed the files and the date of any change.
  24.  
  25. THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.
  26. THE ENTIRE RISK OF THE QUALITY AND PERFORMANCE OF THIS SOFTWARE
  27. IS WITH YOU. SHOULD ANY ELEMENT OF THIS SOFTWARE PROVE DEFECTIVE,
  28. YOU WILL ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR, OR
  29. CORRECTION.
  30.  
  31. The FLOAT64 class is used to represent 64 bit signed double
  32. precision floating point values independently of the operating
  33. system or hardware platform used. It works by separating a 64-bit
  34. value into eight separate byte values and reordering the bytes
  35. highest-order to lowest-order. A FLOAT64 type has a positive
  36. limit of 1.7E+308 and a negative limit of 1.7E-308 with 15-digit
  37. precision. NOTE: In order to maintain the correct byte ordering
  38. on PC based, Intel x86 family, systems the __X86__ macro must be
  39. defined at compile time.
  40.  
  41. In a double precision floating point number, the binary info is
  42. stored within a total of 64 bits. The first bit contains the sign
  43. of the mantissa (0 for positive and 1 for negative). The next 11
  44. bits store the exponent, and the remaining 52 bits provide the
  45. mantissa, giving an approximate decimal precision of 15 digits.
  46. */
  47. // ----------------------------------------------------------- //   
  48. #ifndef __FLOAT64_HPP
  49. #define __FLOAT64_HPP
  50.  
  51. #include "dtypes.h"
  52.  
  53. // Data structure for signed double precision floating point values.
  54. class FLOAT64
  55. {
  56. public:
  57.   FLOAT64(__DPFLOAT__ val = 0);
  58.   FLOAT64(const FLOAT64& ob);
  59.   FLOAT64& operator=(const FLOAT64& ob);
  60.   FLOAT64& operator=(const __DPFLOAT__ ob);
  61.  
  62. public:
  63.   void UnPackBits(__DPFLOAT__ val);
  64.   __DPFLOAT__ PackBits() const;
  65.   
  66. public:
  67.   operator __DPFLOAT__() const;
  68.  
  69. public: // Arithmetic operators that modify their operand
  70.   FLOAT64 operator++(int);  // Postfix
  71.   FLOAT64 operator--(int);  // Postfix
  72.   FLOAT64 &operator++() { operator=(*this + 1); return *this; } // Prefix
  73.   FLOAT64 &operator--() { operator=(*this - 1); return *this; } // Prefix
  74.   void operator+=(const FLOAT64 &fp) { operator=(*this + fp); }
  75.   void operator-=(const FLOAT64 &fp) { operator=(*this - fp); }
  76.   void operator*=(const FLOAT64 &fp) { operator=(*this * fp); }
  77.   void operator/=(const FLOAT64 &fp);
  78.  
  79.   void operator+=(const __DPFLOAT__ &fp) { operator=(*this + fp); }
  80.   void operator-=(const __DPFLOAT__ &fp) { operator=(*this - fp); }
  81.   void operator*=(const __DPFLOAT__ &fp) { operator=(*this * fp); }
  82.   void operator/=(const __DPFLOAT__ &fp);
  83.   
  84.   void operator+=(const __LWORD__ &i) { operator=(*this + i); }
  85.   void operator-=(const __LWORD__ &i) { operator=(*this - i); }
  86.   void operator*=(const __LWORD__ &i) { operator=(*this * i); }
  87.   void operator/=(const __LWORD__ &i);
  88.  
  89.   void operator+=(const __ULWORD__ &i) { operator=(*this + i); }
  90.   void operator-=(const __ULWORD__ &i) { operator=(*this - i); }
  91.   void operator*=(const __ULWORD__ &i) { operator=(*this * i); }
  92.   void operator/=(const __ULWORD__ &i);
  93.  
  94.   void operator+=(const __WORD__ &i) { operator=(*this + i); }
  95.   void operator-=(const __WORD__ &i) { operator=(*this - i); }
  96.   void operator*=(const __WORD__ &i) { operator=(*this * i); }
  97.   void operator/=(const __WORD__ &i);
  98.  
  99.   void operator+=(const __SWORD__ &i) { operator=(*this + i); }
  100.   void operator-=(const __SWORD__ &i) { operator=(*this - i); }
  101.   void operator*=(const __SWORD__ &i) { operator=(*this * i); }
  102.   void operator/=(const __SWORD__ &i);
  103.  
  104.   void operator+=(const __UWORD__ &i) { operator=(*this + i); }
  105.   void operator-=(const __UWORD__ &i) { operator=(*this - i); }
  106.   void operator*=(const __UWORD__ &i) { operator=(*this * i); }
  107.   void operator/=(const __UWORD__ &i);
  108.  
  109.   void operator+=(const __USWORD__ &i) { operator=(*this + i); }
  110.   void operator-=(const __USWORD__ &i) { operator=(*this - i); }
  111.   void operator*=(const __USWORD__ &i) { operator=(*this * i); }
  112.   void operator/=(const __USWORD__ &i);
  113.  
  114.   void operator+=(const __SBYTE__ &i) { operator=(*this + (__DPFLOAT__)i); }
  115.   void operator-=(const __SBYTE__ &i) { operator=(*this - (__DPFLOAT__)i); }
  116.   void operator*=(const __SBYTE__ &i) { operator=(*this * (__DPFLOAT__)i); }
  117.   void operator/=(const __SBYTE__ &i);
  118.  
  119.   void operator+=(const __UBYTE__ &i) { operator=(*this + (__DPFLOAT__)i); }
  120.   void operator-=(const __UBYTE__ &i) { operator=(*this - (__DPFLOAT__)i); }
  121.   void operator*=(const __UBYTE__ &i) { operator=(*this * (__DPFLOAT__)i); }
  122.   void operator/=(const __UBYTE__ &i);
  123.  
  124. public: // Comparison operators
  125.   friend int operator==(const FLOAT64 &a, const FLOAT64 &b);
  126.   friend int operator==(const FLOAT64 &a, const __DPFLOAT__ &bf);
  127.   friend int operator==(const __DPFLOAT__ &af, const FLOAT64 &b);
  128.   friend int operator==(const FLOAT64 &a, const __LWORD__ &bl);
  129.   friend int operator==(const __LWORD__ &al, const FLOAT64 &b);
  130.   friend int operator==(const FLOAT64 &a, const __ULWORD__ &bl);
  131.   friend int operator==(const __ULWORD__ &al, const FLOAT64 &b);
  132.   friend int operator==(const FLOAT64 &a, const __WORD__ &bl);
  133.   friend int operator==(const __WORD__ &al, const FLOAT64 &b);
  134.   friend int operator==(const FLOAT64 &a, const __SWORD__ &bl);
  135.   friend int operator==(const __SWORD__ &al, const FLOAT64 &b);
  136.   friend int operator==(const FLOAT64 &a, const __UWORD__ &bl);
  137.   friend int operator==(const __UWORD__ &al, const FLOAT64 &b);
  138.   friend int operator==(const FLOAT64 &a, const __USWORD__ &bl);
  139.   friend int operator==(const __USWORD__ &al, const FLOAT64 &b);
  140.   friend int operator==(const FLOAT64 &a, const __SBYTE__ &bl);
  141.   friend int operator==(const __SBYTE__ &al, const FLOAT64 &b);
  142.   friend int operator==(const FLOAT64 &a, const __UBYTE__ &bl);
  143.   friend int operator==(const __UBYTE__ &al, const FLOAT64 &b);
  144.  
  145.   friend int operator!=(const FLOAT64 &a, const FLOAT64 &b);
  146.   friend int operator!=(const FLOAT64 &a, const __DPFLOAT__ &bf);
  147.   friend int operator!=(const __DPFLOAT__ &af, const FLOAT64 &b);
  148.   friend int operator!=(const FLOAT64 &a, const __LWORD__ &bl);
  149.   friend int operator!=(const __LWORD__ &al, const FLOAT64 &b);
  150.   friend int operator!=(const FLOAT64 &a, const __ULWORD__ &bl);
  151.   friend int operator!=(const __ULWORD__ &al, const FLOAT64 &b);
  152.   friend int operator!=(const FLOAT64 &a, const __WORD__ &bl);
  153.   friend int operator!=(const __WORD__ &al, const FLOAT64 &b);
  154.   friend int operator!=(const FLOAT64 &a, const __SWORD__ &bl);
  155.   friend int operator!=(const __SWORD__ &al, const FLOAT64 &b);
  156.   friend int operator!=(const FLOAT64 &a, const __UWORD__ &bl);
  157.   friend int operator!=(const __UWORD__ &al, const FLOAT64 &b);
  158.   friend int operator!=(const FLOAT64 &a, const __USWORD__ &bl);
  159.   friend int operator!=(const __USWORD__ &al, const FLOAT64 &b);
  160.   friend int operator!=(const FLOAT64 &a, const __SBYTE__ &bl);
  161.   friend int operator!=(const __SBYTE__ &al, const FLOAT64 &b);
  162.   friend int operator!=(const FLOAT64 &a, const __UBYTE__ &bl);
  163.   friend int operator!=(const __UBYTE__ &al, const FLOAT64 &b);
  164.  
  165.   friend int operator<(const FLOAT6